Wise Objects for Calm Technology

International audienceIn this position paper we identify the design of “wise systems” as an open research problem addressing new technology-based systems. Increasing complexity and sophistication make those systems hard to understand and to master. Human users are very often involved in learning processes that capture all their attention while being of little interest for them. To alleviate human interaction with such systems, as the foundation of our current research, we propose the concept of “wise object” as the building block. Software-based systems would then be able to autonomously learn on themselves and on the way humans use them. Humans would in turn be prompted only when necessary by the system

An Architecture-Centric Approach for Information System Architecture Modeling, Enactement and Evolution

International audienc

Package Fingerprint: a visual summary of package interfaces and relationships

International audienceContext: Object-oriented languages such as Java, Smalltalk, and C++ structure their programs using packages. Maintainers of large systems need to understand how packages relate to each other, but this task is complex because packages often have multiple clients and play different roles (class container, code ownership. . . ). Several approaches have been proposed, among which the use of cohesion and coupling metrics. Such metrics help identify candidate packages for restructuring; however, they do not help maintainers actually understand the structure and interrelation- ships between packages. Objectives: In this paper, we use pre-attentive processing as the basis for package visualization and see to what extent it could be used in package understanding. Method: We present the package fingerprint, a 2D visualization of the references made to and from a package. The proposed visualization offers a semantically rich, but compact and zoomable views centered on packages. We focus on two views (incoming and outgoing references) that help users understand how the package under analysis is used by the system and how it uses the system. Results: We applied these views on four large systems: Squeak, JBoss, Azureus, and ArgoUML. We obtained several interesting results, among which, the identification of a set of recurring visual patterns that help maintainers: (a) more easily identify the role of and the way a package is used within the system (e.g., the package under analysis provides a set of layered services), and, (b) detect either problematic situations (e.g., a single package that groups together a large number of basic services) or opportunities for better package restructuring (e.g., removing cyclic dependencies among packages). The visualization generally scaled well and the detection of different patterns was always possible. Conclusion: The proposed visualizations and patterns proved to be useful in understanding and maintaining the different systems we addressed. To generalize to other contexts and systems, a real user study is required

The Package Blueprint: visually analyzing and quantifying package dependencies

International audienceLarge object-oriented applications are structured over many packages. Packages are important but complex structural entities that are difficult to understand since they act as containers of classes, which can have many dependencies with other classes spread over multiple packages. However to be able to take decisions (e.g., refactoring and/or assessment decisions), maintainers face the challenges of managing (sorting, grouping) the massive amount of dependencies between classes spread over multiple packages. To help maintainers, there is a need for at the same time understanding, and quantifying, dependencies between classes as well as understanding how packages as containers of such classes depend on each other. In this paper, we present a visualization, named Package Blueprint, that reveals in detail package internal structure, as well as the dependencies between an observed package and its neighbors, at both package and class levels. Package Blueprint aims at assisting maintainers in understanding package structure and dependencies, in particular when they focus on few packages and want to take refactoring decisions and/or to assess the structure of those packages. A package blueprint is a space filling matrix-based visualization, using two placement strategies that are enclosure and adjacency. Package blueprint is structured around the notion of surfaces that group classes and their dependencies by their packages (i.e., enclosure placement); whilst surfaces are placed next to their parent node which is the package under-analysis (i.e., adjacency placement). We present two views: one stressing how an observed package depends upon the rest of the system and another stressing how the system depends upon that package. To evaluate the contribution of package blueprint for understanding packages we performed an exploratory user study comparing package blueprint with an advanced IDE. The results shows that users of package blueprint are faster in analyzing and assessing package structure. The results are proved statically significant and they show that package blueprint considerably improve the experience of standard browser users

Supporting Decentralised Software-intensive Processes using Zeta Component-based Architecture Description Language

International audienc

A Wise Object Framework for Distributed Intelligent Adaptive Systems

International audienceDesigning Intelligent Adaptive Distributed Systems is an open research issue addressing nowadays technologies such as Communicating Objects (COT) and the Internet of Things (IoT) that increasingly contribute to our daily life (mobile phones, computers, home automation, etc.). Complexity and sophistication of those systems make them hard to understand and to master by human users, in particular end-users and developers. Those are very often involved in learning processes that capture all their attention while being of little interest for them. To alleviate human interaction with such systems and help developers to produce them, we propose WOF, an object oriented framework founded on the concept of \emph{Wise Object} (WO). A WO is a software-based entity that is able to learn on itself and also on the others (e.g. its environment). Wisdom refers to the experience (on its own behavior and on the usage done of it) such object acquires by its own during its life. In the paper, we present the WOF conceptual architecture and the Java implementation we built from it. Requirements and design principles of wise systems are presented. To provide application (e.g. home automation system) developers with relevant support, we designed WOF with the minimum intrusion in the application source code. The adaptiveness, intelligence and distribution related mechanisms defined in WOF are inherited by application classes. In our Java implementation of WOF, object classes produced by a developer inherit the behavior of Wise Object (WO) class. An instantiated system is then a Wise Object System (WOS) composed of wise objects that interact through an event bus according to publish-subscribe design pattern

Supporting Distributed and Adaptive Workflow Process Systems

International audienc

Approche centrée architecture pour l'évolution dynamique de systèmes

National audienceLa prise en compte de l'évolution très tôt dans le développement du logiciel est un phénomène assez récent et va de paire avec l'apparition de langages de description architecturale à fort pouvoir d'expression, tels que ACME, Wright, etc. C'est notamment dans les approches centrées architecture de ces dernières années que sont apparus des langages de description architecturale intégrant des mécanismes permettant de prendre en compte l'évolution d'une architecture logicielle. Plusieurs types d'évolution peuvent être mis en évidence, selon que l'évolution est prévue ou non, qu'elle est mise en oeuvre en temps de conception ou en temps d'exécution. La majorité des approches traitant de l'évolution de systèmes logiciels, le font seulement au niveau de l'implémentation. Ceci implique des problèmes liés à gestion de la cohérence entre l'implémentation et l'architecture du système, conduisant notamment à des architectures inutilisables car obsolètes. Nous proposons de répondre à ce problème par l'utilisation de l'approche centrée architecture ArchWare, fondée sur des mécanismes et proposant des outils support qui permettent de couvrir différents types d'évolution que nous illustrons à travers des scénarios

Approche centrée architecture pour l'évolution dynamique de systèmes

National audienceLa prise en compte de l'évolution très tôt dans le développement du logiciel est un phénomène assez récent et va de paire avec l'apparition de langages de description architecturale à fort pouvoir d'expression, tels que ACME, Wright, etc. C'est notamment dans les approches centrées architecture de ces dernières années que sont apparus des langages de description architecturale intégrant des mécanismes permettant de prendre en compte l'évolution d'une architecture logicielle. Plusieurs types d'évolution peuvent être mis en évidence, selon que l'évolution est prévue ou non, qu'elle est mise en oeuvre en temps de conception ou en temps d'exécution. La majorité des approches traitant de l'évolution de systèmes logiciels, le font seulement au niveau de l'implémentation. Ceci implique des problèmes liés à gestion de la cohérence entre l'implémentation et l'architecture du système, conduisant notamment à des architectures inutilisables car obsolètes. Nous proposons de répondre à ce problème par l'utilisation de l'approche centrée architecture ArchWare, fondée sur des mécanismes et proposant des outils support qui permettent de couvrir différents types d'évolution que nous illustrons à travers des scénarios

Visualisation, évaluation et re-modularisation des éléments architecturaux oriéntés objet

Pour faire face à la complexité des grands systèmes logiciels orientés objets, les programmeurs organisent les classes en sous-systèmes en utilisant les concepts de module ou de package. Une telle structure modulaire permet aux systèmes logiciels d évoluer face aux nouvelles exigences. L organisation des classes dans des packages et / ou sous-systèmes, que nous appelons la modularisation du logiciel, suit habituellement les relations entre les classes. Il est d'usage de vouloir les packages faiblement couplés et assez cohésifs. Cependant, les études montrent que quand les systèmes logiciels s adaptent aux exigences et aux modifications de l environnement, leurs modularisations dérivent et perdent progressivement leur qualité. En conséquence, la modularisation des systèmes logiciels doit être maintenue. Il est donc important de comprendre, d évaluer et d optimiser l organisation des packages et de leurs relations. Le point défendu dans la thèse est que le maintien des modularisations logiciels de grande taille et complexes requiert des approches qui contribuent à: (1) la compréhension des packages et de leurs relations; (2) l évaluation de la qualité d une modularisation, ainsi que la qualité d un package dans le contexte d une modularisation donnée; (3) l optimisation de la qualité d une modularisation existante. Dans cette thèse, nous nous concentrons sur trois domaines de recherche: visualisations de programmes, métriques et algorithmes. Dans un premier temps, nous définissons deux visualisations qui aident les mainteneurs à: (1) la compréhension de la structure des packages, et de leurs utilisations et leurs relations; (2) l identification des modèles; et (3) l identification des anomalies structurelles. En plus de visualisations, nous définissons un ensemble de métriques qui aident à évaluer la qualité d un package (i.e., la cohésion et le couplage). Nous définissons également des métriques qui permettent d évaluer la qualité d une collection des packages inter-dépendants. Ceci en prenant en compte le degré de couplage et de cycles entre les packages. Enfin, nous définissons un algorithme de recherche qui réduit automatiquement le couplage et les cycles entre les packages, en déplaçant seulement les classes sur les packages existants. Notre approche d optimisation prend explicitement en compte l organisation des classes et la structure originale des packages. Il permet également aux mainteneurs de contrôler le processus d optimisation en spécifiant: (1) le nombre maximal des classes qui peuvent changer leurs packages; (2) les classes qui sont candidates pour se déplacer et celles qui ne doivent pas changer leurs packages; (3) les packages qui sont candidates pour la restructuration et ceux qui ne doivent pas se changer; et (4) le nombre maximal des classes qu un package donné peut contenir. Les approches présentées dans cette thèse ont été appliquées à des systèmes logiciels orienté objets, réels et de grand taille. Les résultats obtenus démontrent l utilité de nos visualisations et métriques, et l efficacité de notre algorithme d optimisation.To cope with the complexity of large object-oriented software systems, developers organize classes into subsystems using the concepts of module or package. Such modular structure helps software systems to evolve when facing new requirements.The organization of classes into packages and/or subsystems represents the software modularization. the software modularization usually follows interrelationships between classes. Ideally, packages should to be loosely coupled and cohesive to a certain extent. However, Studies show that as software evolves to meet requirements and environment changes, the software modularization gradually drifts and looses quality. As a consequence, the software modularization must be maintained. It is thus important to understand, to assess and to optimize the organization of packages and their relationships. Our claim is that the maintenance of large and complex software modularizations needs approaches that help in: (1) understanding package shapes and relationships; (2) assessing the quality of a modularization, as well as the quality of a single package within a given modularization; (3) optimizing the quality of an existing modularization. In this thesis, we concentrate on three research fields: software visualizations, metrics and algorithms. At first, we define two visualizations that help maintainers: (1) to understand packages structure, usage and relationships; (2) to spot patterns; and (3) to identify misplaced classes and structural anomalies. In addition to visualizations, we define a suite of metrics that help in assessing the package design quality (i.e., package cohesion and coupling). We also define metrics that assess the quality of a collection of inter-dependent packages from different view points, such as the degree of package coupling and cycles. Finally, we define a search-based algorithm that automatically reduces package coupling and cycles only by moving classes over existing packages. Our optimization approach takes explicitly into account the original class organization and package structure. It also allows maintainers to control the optimization process by specifying: (1) the maximal number of classes that may change their packages; (2) the classes that are candidate for moving and the classes that should not; (3) the packages that are candidate for restructuring and the packages that should not; and (4) the maximal number of classes that a given package can entail.The approaches presented in this thesis have been applied to real large object-oriented software systems. The results we obtained demonstrate the usefulness of our visualizations and metrics; and the effectiveness of our optimization algorithm.LILLE1-Bib. Electronique (590099901) / SudocSudocFranceF